layui.use(['table','layer','form', 'layedit','jquery'], function(){
    var table = layui.table
        ,layer = layui.layer
        ,form = layui.form
        ,$ = layui.jquery
        ,element = layui.element;

    var body = "";
    var checkStatus;//多选框选中状态
    var checkedData = "";
    var allDataLength = 0;//table中加载得数据总长度

    //获取选中行数据
    function getCheckedDatas(){
        var rows = layui.table.checkStatus('dictionary_table').data;
        console.log("rows="+rows);
        return rows;
    }

    //监听复选框选择事件
    table.on('checkbox(dictionary_table)', function(obj){
        var checked = obj.checked;//当前是否选中状态
        var checkeddata = obj.data;//选中行的相关数据
        var checkedRowNums = getCheckedDatas().length;//选中数据条数
        console.log("选中数据条数="+checkedRowNums);
        console.log("checkeddata",checkeddata);

        //全选状态下--->只解禁删除按钮
        if(checkedRowNums==allDataLength){
            $("#delete_id").removeClass("layui-btn-disabled");
            $("#delete_id").attr("disabled",false);
        }
        //非全选 但是 多选状态下--->同时解禁删除/修改按钮
        if(checkedRowNums>=1 && checkedRowNums<allDataLength){
            //解禁删除按钮
            $("#delete_id").removeClass("layui-btn-disabled");
            $("#delete_id").attr("disabled",false);
            //禁掉修改按钮
            $("#update_id").addClass("layui-btn-disabled");
            $("#update_id").attr("disabled",true);
        }
        //单选状态下--->同时解禁删除/修改按钮
        if(checkedRowNums==1){
            $("#update_id,#delete_id").removeClass("layui-btn-disabled");
            $("#update_id,#delete_id").attr("disabled",false);
        }
        //未选中状态下--->同时禁掉删除/修改按钮
        if(checkedRowNums==0){
            $("#update_id,#delete_id").addClass("layui-btn-disabled");
            $("#update_id,#delete_id").attr("disabled",true);
        }
    });


    //新增字典信息
    function addDictionaryType(body,url){
        var dicId = body.find("#dicId").val();
        var dicName = body.find("#dicName").val();
        var dicCode = body.find("#dicCode").val();
        var remark = body.find("#remark").val();
        if(dicName == ''){
            layer.msg('字典名称不能为空！',function() {time:500});
            return false;
        }
        if(dicCode == ''){
            layer.msg('字典码不能为空！',function() {time:500});
            return false;
        }
        $.ajax({
            url:url,
            type:'GET',
            async:true,
            data:{
                dicId:dicId,
                dicCode:dicCode,
                dicName:dicName,
                remark:remark
            },
            timeout:5000,    //超时时间
            dataType:'json', //返回的数据格式：json/xml/html/script/jsonp/text
            success:function(res){
                layer.msg("新增字典类型成功！");
                return true;
            },
            error:function(res){
                layer.msg("新增字典类型出错了！");
                return false;
            },
            complete:function(){
                //刷新父页面数据
                location.reload();
            }
        });
    }

    //生成字典ID
    function setDicId(body,url){
        $.ajax({
            url:url,
            type:'GET',
            async:true,
            timeout:5000,    //超时时间
            dataType:'json', //返回的数据格式：json/xml/html/script/jsonp/text
            success:function(res){
                //添加字典类型得时候自动生成得字典id
                body.find("#dicId").val(res.data.maxid+1);
            },
            error:function(data){
                layer.msg('请求失败，出现了未知错误!');
            }
        });
    }

    //根据dicCode查询字典类型信息并给文本框赋值
    function setDictionaryTypeInfo(body,dicId,url){
        $.ajax({
            url:url,
            type:'GET',
            data:{dicId:dicId},
            async:false,
            timeout:5000,    //超时时间
            dataType:'json', //返回的数据格式：json/xml/html/script/jsonp/text
            success:function(res){
                //设值
                body.find("#dicId").val(res.data.dicId);
                body.find("#dicCode").val(res.data.dicCode);
                body.find("#dicName").val(res.data.dicName);
                body.find("#remark").val(res.data.remark);
            },
            error:function(data){
                layer.msg('请求失败，出现了未知错误!');
            }
        });
    }

    //根据dicCode查询字典类型信息并给文本框赋值
    function setDicTypeInfo(body,params){
        var data = JSON.parse(params);
        console.log("params类型",params instanceof Object);
        console.log("data类型",data instanceof Object);
        console.log(params,'值');
        console.log(data,'data');
        $.each(data,function(n,value) {
            console.log(value,'value值');
            body.find("#dicId").val(value.DIC_id);
            body.find("#dicCode").val(value.DIC_code);
            body.find("#dicName").val(value.DIC_name);
            body.find("#remark").val(value.remark);
            console.log("value",value);
        });

        form.render();

    }


    //根据dicId修改字典类型信息
    function updateDictionaryTypeInfo(body,url){
        //获取修改后的字典信息
        var dicId = body.find("#dicId").val();
        var dicCode = body.find("#dicCode").val();
        var dicName = body.find("#dicName").val();
        var remark = body.find("#remark").val();
        $.ajax({
            url:url,
            type:'GET',
            data:{
                dicId:dicId,
                dicCode:dicCode,
                dicName:dicName,
                remark:remark
            },
            async:true,
            timeout:5000,    //超时时间
            dataType:'json', //返回的数据格式：json/xml/html/script/jsonp/text
            success:function(res){
                layer.msg('修改字典信息成功!');
            },
            error:function(data){
                layer.msg('出现了未知错误，修改字典信息失败!');
            }
        });
    }

    var status="";
    //dicCode输入框失去焦点时候判断用户输入的dicCode是否已存在
    $("#dicCode").blur(function(){
        $.ajax({
            url:'../dictionaryType/isExistDicCode.json',
            type:'GET',
            async:false,
            data:{
                dicCode:$("#dicCode").val()
            },
            timeout:5000,    //超时时间
            dataType:'json', //返回的数据格式：json/xml/html/script/jsonp/text
            success:function(res){
                //status如果为真值，则用户输入的dicCode已被注册过，给出用户提醒
                if(res.data){
                    layer.msg('该 字典码 已存在，请重新输入!');
                }
            },
            error:function(data){
                layer.msg('请求失败，出现了未知错误!');
            }
        });
    });

    table.render({
        elem: '#dictionary_table'
        ,id:'dictionary_table_id'
        ,url:'../dictionaryType/getDictionaryByKeys.json'
        ,response: {
            statusName: 'code'
            ,statusCode: '100012'
            ,msgName: 'msg'
            ,countName: 'total'
            ,dataName: 'data'
        }
        ,defaultToolbar: ['filter', 'print','exports']
        ,toolbar: '#toolbar'
        ,title: '字典类型'
        ,cols: [[
            {type: 'checkbox', fixed: 'left'}
            ,{field:'DIC_id', title:'字典主键', fixed: 'left', sort: true,unresize: true, width:150}
            ,{field:'DIC_name', title:'字典名称'}
            ,{field:'DIC_code', title:'字典码',sort: true}
            ,{field:'remark', title:'备注'}
            ,{fixed: 'right', title:'操作', toolbar: '#operations', width:300}
        ]]
        ,page: true
        ,done: function(res, curr, count){
            allDataLength = count;//给变量赋值，保存表格初始数据总长度
            //如果是异步请求数据方式，res即为你接口返回的信息。
            //如果是直接赋值的方式，res即为：{data: [], count: 99} data为当前页数据、count为数据总长度
            console.log(res);
            //得到当前页码
            console.log(curr);
            //得到数据总量
            console.log("数据长度="+count);
    }
    });

    //打开弹出层表单
    function openForm(title,event,url1,url2,params){
        layer.open({
            type: 2,
            area:['35%', '60%'],
            fixed:true,
            anim: 2,
            maxmin:false,
            scrollbar: false,
            title: title,
            content: ['/page/addDictionaryType.html','no'],
            btn:['确认','取消'],
            success: function(layero, index) {
                //设置body为全局变量
                body = layer.getChildFrame('body',index);
                switch (event) {
                    case 'add_dic':
                        //给新增字典记录生成字典id
                        //url1--->新增字典类型获取当前最大字典ID接口url
                        var aa= layui.table.checkStatus('dictionary_table').data;
                        console.log("选中数据长度="+aa);
                        setDicId(body,url1);
                        layer.iframeAuto(index);
                        break;
                    case 'update_dic':
                        //修改信息的时候禁用掉dicCode输入框的blur事件
                       //给所有文本框赋值
                        setDicTypeInfo(body,params);
                        break;
                }

            },
            yes: function(index, layero){
                //body = layer.getChildFrame('body',index);
                switch (event) {
                    case 'add_dic':
                        $('#dicCode').trigger('blur');
                        //添加字典类型
                        //url2--->将新增字典类型信息保存到数据的url
                        addDictionaryType(body,url2);
                        break;
                    case 'update_dic':
                        //修改后提交保存
                        //url2--->修改数据库字典类型信息的url
                        updateDictionaryTypeInfo(body,url2);
                        break;
                }


            }
            ,btn2: function(index, layero){
                layer.close(index);
                return false;
            }
        });
    }

    //删除选中行同时兼容多选和单选
    function delDicTypeByIds(url,idsStr){
        var status = "0";
        $.ajax({
            url:url,
            type:'GET',
            async:true,
            data:{idsStr:idsStr},
            timeout:5000,    //超时时间
            dataType:'json', //返回的数据格式：json/xml/html/script/jsonp/text
            success:function(res){
                if(res.data == true){
                    layer.msg('删除成功!');

                    status = "1";
                }else{
                    layer.msg('删除失败!');
                    status = "0";
                }
            },
            error:function(data){
                layer.msg('出现未知异常，删除失败!');
                status = "0";
            }
        });
        if(status==0){
            return false;
        }else{
            return true;
        }
    }


    //头工具栏事件
    table.on('toolbar(dictionary_table)', function(obj){
        //设置选中状态为全局变量
        checkStatus = table.checkStatus(obj.config.id);
   /*     var index = parent.layer.getFrameIndex(window.name);
        parent.layer.iframeAuto(index);*/
        switch(obj.event){
            case 'getCheckData':
                var data = checkStatus.data;
                layer.alert(JSON.stringify(data));
                break;
            case 'getCheckLength':
                var data = checkStatus.data;
                layer.msg('选中了：'+ data.length + ' 个');
                break;
            case 'isAll':
                layer.msg(checkStatus.isAll ? '全选': '未全选');
                break;
            case 'add_dic':
                openForm('新增字典类型','add_dic','../dictionaryType/getMaxDIC_id.json','../dictionaryType/addDictionaryType.json',null);
                break;
            case 'update_dic':
                var params = JSON.stringify(checkStatus.data);
                console.log("params类型",params instanceof Object);
                console.log(params,'工具栏参数');
                openForm('修改字典类型','update_dic',null,'../dictionaryType/updateDictionaryTypeById.json',params);
                reloadTable('../dictionaryType/getDictionaryByKeys.json',"");
                break;
            case 'delete_dic':
                //获取要删除的行id
                var delData = checkStatus.data;
                var delStr = "";
                //解析要删除的数据
                $.each(delData,function(index,value){
                    delStr+=value.DIC_id+',';
                });
                //进一步处理要删除的数据行的id
                delStr = delStr.substring(0,delStr.length-1);
                //询问是否要真的删除
                layer.msg('删除后不可恢复，<br>请谨慎操作！', {
                    title:'提示:',
                    time: 20000, //20s后自动关闭
                    btn: ['确定', '取消'],
                    area:['25%','40%'],
                    yes : function(index,layero){
                        //点击确定，执行删除
                        var flag = delDicTypeByIds('../dictionaryType/deleteDictionaryTypeByIds.json',delStr);
                        alert("flag="+flag);
                        if(flag){
                            //重载表格
                            reloadTable('../dictionaryType/getDictionaryByKeys.json',"");
                            layero.msg("删除成功!");
                        }
                    },

                    btn2 : function(index,layero){
                        alert("index="+index);
                    }
                    //icon:2
                });
                break;
        };
    });

    //表格重载
    function reloadTable(url,param){
        table.reload('dictionary_table_id',{
            url:url
            ,method: 'get'
            ,where: {
                searchkey:param
            }
            ,page: {
                curr: 1
            }
        }, 'data');
    }

    //搜索
    $("#searchbox").on("click",function(){
        //获取要搜索的词条
        var searchkey = $("#search_target").val();
        console.log("searchkey:",searchkey);
        reloadTable('../dictionaryType/getDictionaryByKeys.json',searchkey);
    });

    /*function openDicItemTab(){
        element.tabAdd('item_table', {
            title: '字典详情'
            ,content: '/page/dictionaryItem.html'
            ,id: 'item_table_id'
        });
    }*/


    //监听行工具事件
    table.on('tool(dictionary_table)', function(obj){
        var data = obj.data;//获取当前行数据
        var dicId = data.DIC_id;//获取操作行dicId
        //console.log("itemId=",itemId);
        switch(obj.event){
            //删除
            case 'del':
                layer.confirm('删除后将不可恢复，请谨慎操作！', function(index){
                    delDicTypeByIds('../dictionaryType/deleteDictionaryTypeByIds.json',dicId);
                    obj.del();
                    layer.close(index);
                });
                break;
            //编辑
            case 'edit':
                var array = new Array();
                array.push(data);
                var params = JSON.stringify(array);
                openForm('修改字典类型','update_dic',null,'../dictionaryType/updateDictionaryTypeById.json',params);
                break;
            //列表
            case 'list_detail':
                //获取行数据
                //openDicItemTab();
                /*element.tabAdd('item_table', {
                    title: '字典详情'
                    ,content: '/page/dictionaryItem.html'
                    ,id: 'item_table_id'
                });*/
                break;
        }
    });


    //页面加载完成设置按钮样式
    $(function(){
        var checkedData = getCheckedDatas();
        var length = checkedData.length;
        //未选中任何数据情况下按钮置灰
        if(length<=0){
            //设置按钮置灰样式
            $("#update_id,#delete_id").addClass("layui-btn-disabled");
            //设置置灰不可用状态
            $("#update_id,#delete_id").attr("disabled",true);
        }else{
            //解除按钮置灰
            $("#update_id,#delete_id").removeClass("layui-btn-disabled");
            //解除按钮不可用状态
            $("#update_id,#delete_id").removeClass(disabled);
        }
        console.log('length='+length);
        console.log("checkedData="+checkedData);
        console.log("数据类型="+typeof checkedData);
    });


});

